#!/bin/bash

# PHY Test 自动化构建脚本
# 支持多平台编译和一键部署

set -e  # 遇到错误立即退出

# 脚本信息
SCRIPT_NAME="PHY Test Build Script"
VERSION="1.0.0"
BUILD_DATE=$(date '+%Y-%m-%d %H:%M:%S')

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 日志函数
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 显示横幅
show_banner() {
    echo "=================================="
    echo "  $SCRIPT_NAME v$VERSION"
    echo "  Build Date: $BUILD_DATE"
    echo "=================================="
    echo ""
}

# 显示帮助信息
show_help() {
    cat << EOF
用法: $0 [选项] [目标]

选项:
  -h, --help          显示帮助信息
  -v, --version       显示版本信息
  -c, --clean         构建前清理
  -d, --debug         构建调试版本
  -j N, --jobs N      并行编译任务数 (默认: 4)
  --arch ARCH         指定目标架构 (x86_64, arm, riscv)
  --cross-all         交叉编译所有平台
  --install           构建后安装到系统
  --package           创建发布包
  --test              构建后运行测试
  --analyze           运行代码静态分析
  --format            格式化源代码

目标:
  build              默认构建 (release版本)
  debug              构建调试版本
  release            构建发布版本
  clean              清理构建文件
  install            安装到系统
  uninstall          从系统卸载
  test               运行测试
  package            创建发布包
  help               显示帮助信息

示例:
  $0                      # 默认构建
  $0 --clean build        # 清理后构建
  $0 --debug --test       # 构建调试版本并测试
  $0 --arch arm           # ARM平台交叉编译
  $0 --cross-all          # 所有平台交叉编译
  $0 --install            # 构建并安装

EOF
}

# 显示版本信息
show_version() {
    echo "$SCRIPT_NAME v$VERSION"
    echo "Build Date: $BUILD_DATE"
}

# 检查依赖工具
check_dependencies() {
    log_info "检查构建依赖..."
    
    local missing_deps=()
    
    # 检查基本工具
    if ! command -v make &> /dev/null; then
        missing_deps+=("make")
    fi
    
    if ! command -v gcc &> /dev/null; then
        missing_deps+=("gcc")
    fi
    
    # 检查交叉编译工具链（可选）
    if [[ "$ARCH" == "arm" ]] && ! command -v arm-nextvpu-linux-gnueabihf-gcc &> /dev/null; then
        log_warning "ARM交叉编译器未找到"
    fi
    
    if [[ "$ARCH" == "riscv" ]] && ! command -v riscv64-anyka-linux-musl-gcc &> /dev/null; then
        log_warning "RISC-V交叉编译器未找到"
    fi
    
    if [ ${#missing_deps[@]} -ne 0 ]; then
        log_error "缺少必要依赖: ${missing_deps[*]}"
        log_info "请安装缺少的依赖后重试"
        exit 1
    fi
    
    log_success "依赖检查完成"
}

# 检查系统资源
check_system() {
    log_info "检查系统资源..."
    
    # 检查磁盘空间 (至少需要100MB)
    available_space=$(df . | awk 'NR==2 {print $4}')
    required_space=102400  # 100MB in KB
    
    if [ "$available_space" -lt "$required_space" ]; then
        log_warning "可用磁盘空间不足 (需要至少100MB)"
    fi
    
    # 检查内存 (至少需要512MB)
    available_memory=$(free -m | awk 'NR==2{print $7}')
    required_memory=512
    
    if [ "$available_memory" -lt "$required_memory" ]; then
        log_warning "可用内存不足 (需要至少512MB)"
    fi
    
    log_success "系统资源检查完成"
}

# 清理构建文件
clean_build() {
    log_info "清理构建文件..."
    make clean
    log_success "清理完成"
}

# 执行构建
do_build() {
    local target="$1"
    local make_flags=""
    
    log_info "开始构建目标: $target"
    
    # 设置并行编译
    if [ -n "$JOBS" ]; then
        make_flags+=" -j$JOBS"
    fi
    
    # 设置调试模式
    if [ "$DEBUG" = "1" ]; then
        make_flags+=" DEBUG=1"
    fi
    
    # 设置目标架构
    if [ -n "$ARCH" ]; then
        make_flags+=" ARCH=$ARCH"
    fi
    
    # 执行make命令
    if make $make_flags $target; then
        log_success "构建完成: $target"
        return 0
    else
        log_error "构建失败: $target"
        return 1
    fi
}

# 运行测试
run_tests() {
    log_info "运行测试..."
    
    if make test; then
        log_success "所有测试通过"
        return 0
    else
        log_error "测试失败"
        return 1
    fi
}

# 安装程序
install_program() {
    log_info "安装程序到系统..."
    
    if make install; then
        log_success "安装完成"
        return 0
    else
        log_error "安装失败"
        return 1
    fi
}

# 创建发布包
create_package() {
    log_info "创建发布包..."
    
    if make package; then
        log_success "发布包创建完成"
        return 0
    else
        log_error "发布包创建失败"
        return 1
    fi
}

# 代码分析
run_analysis() {
    log_info "运行代码静态分析..."
    
    if make analyze; then
        log_success "代码分析完成"
        return 0
    else
        log_error "代码分析失败"
        return 1
    fi
}

# 代码格式化
format_code() {
    log_info "格式化源代码..."
    
    if make format; then
        log_success "代码格式化完成"
        return 0
    else
        log_error "代码格式化失败"
        return 1
    fi
}

# 交叉编译所有平台
cross_compile_all() {
    log_info "开始交叉编译所有平台..."
    
    if make cross-compile; then
        log_success "交叉编译完成"
        return 0
    else
        log_error "交叉编译失败"
        return 1
    fi
}

# 主函数
main() {
    # 默认参数
    local clean_first=0
    local run_install=0
    local run_test=0
    local run_package=0
    local run_analysis=0
    local run_format=0
    local cross_all=0
    local target="build"
    
    DEBUG=0
    JOBS=4
    ARCH=""
    
    # 解析命令行参数
    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                show_help
                exit 0
                ;;
            -v|--version)
                show_version
                exit 0
                ;;
            -c|--clean)
                clean_first=1
                shift
                ;;
            -d|--debug)
                DEBUG=1
                shift
                ;;
            -j|--jobs)
                JOBS="$2"
                shift 2
                ;;
            --arch)
                ARCH="$2"
                shift 2
                ;;
            --cross-all)
                cross_all=1
                shift
                ;;
            --install)
                run_install=1
                shift
                ;;
            --test)
                run_test=1
                shift
                ;;
            --package)
                run_package=1
                shift
                ;;
            --analyze)
                run_analysis=1
                shift
                ;;
            --format)
                run_format=1
                shift
                ;;
            build|debug|release|clean|install|uninstall|test|package|help)
                target="$1"
                shift
                ;;
            *)
                log_error "未知参数: $1"
                show_help
                exit 1
                ;;
        esac
    done
    
    # 显示横幅
    show_banner
    
    # 检查依赖和系统
    check_dependencies
    check_system
    
    # 执行清理（如果需要）
    if [ "$clean_first" = "1" ]; then
        clean_build
    fi
    
    # 代码格式化（如果需要）
    if [ "$run_format" = "1" ]; then
        format_code
    fi
    
    # 代码分析（如果需要）
    if [ "$run_analysis" = "1" ]; then
        run_analysis
    fi
    
    # 交叉编译所有平台
    if [ "$cross_all" = "1" ]; then
        cross_compile_all
    else
        # 执行构建
        case $target in
            clean)
                clean_build
                ;;
            help)
                show_help
                ;;
            *)
                do_build "$target"
                ;;
        esac
    fi
    
    # 运行测试（如果需要）
    if [ "$run_test" = "1" ]; then
        run_tests
    fi
    
    # 安装程序（如果需要）
    if [ "$run_install" = "1" ]; then
        install_program
    fi
    
    # 创建发布包（如果需要）
    if [ "$run_package" = "1" ]; then
        create_package
    fi
    
    log_success "所有任务完成"
}

# 运行主函数
main "$@"